/**
 * JFClientConnecte.java    23/03/2012
 */

package l3.info.Projet.Client;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.rmi.NotBoundException;
import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.DefaultListCellRenderer;
import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.ScrollPaneConstants;
import l3.info.Projet.Client.JDAPropos;
import l3.info.Projet.Client.JDAjoutSuivi;
import l3.info.Projet.Client.JFAuthentification;

/**
 * Représente la JFrame lorsque l'utilisateur
 * est connecté
 * @author Loïc Martinez
 * @version 1.0
 */

public class JFClientConnecte extends JFrame implements ActionListener,
MouseListener {

    /** Constantes */
    private static final String TITRE = "MessageFolder : ";
    private static final String DCNX = "Déconnexion";
    private static final String QUITTER = "Quitter";
    private static final String AJOUT = "Ajout suivi";
    private static final String FICHIER = "Fichier";
    private static final String AIDE = "Aide";
    private static final String APROPOS = "A propos...";
    private static final String UTILISATEURS_SUIVIS = "Utilisateurs suivis";
    private static final String MSG_ECRIT_PAR = "Messages écrits par ";
    private static final int LARGEUR_PAN_BOUTON = 50;
    private static final int HAUTEUR_PAN_BOUTON = 100;
    private static final int ABSCISSE = 250;
    private static final int ORDONNEE = 100;
    private static final int  LARGEUR = 685;
    private static final int HAUTEUR = 600; // 565; +35
    private static final Dimension SCROLL_SIZE = new Dimension(140, 447);
    private static final Dimension DIMENSION_PG = new Dimension(140, 400);
    private static final Dimension MIN_DIMENSION_PANEL =
            new Dimension(343, 300);
    private static final Color BACKGROUND_COLOR = new Color(255, 255, 255);
    private static final String DEBUT_DATE = "Date min ";
    private static final String FIN_DATE = " Date max ";
    private static final JLabel debutDate = new JLabel(DEBUT_DATE);
    private static final JLabel finDate = new JLabel(FIN_DATE);
    private static final String DATE = "OK";
    private static final int NB_DISPLAY_MESSAGES = 5;

    /** Notre pseudo */
    private String myPseudo;

    /** Les JPanel de gauche et de droite */
    private JPanel panelGauche, panelDroite, buttonPane, datePane;

    /** splitPane pour séparer la droite et la gauche,
     *  splitPane2 pour avoir une partie en bas (panelBouton)
     */
    private JSplitPane splitPane,splitPane2;

    /** Le JPanel pour les boutons (en bas de la fenêtre) */
    private JPanel panelBouton;

    /** Les 3 boutons de la JFrame */
    private JButton boutonEcrire, boutonAjouter, boutonSupprimer,
    boutonPrecedent, boutonSuivant, boutonDate;

    /** La liste des personnes suivies */
    private JList list;

    /** Permet d'avoir une barre de scrolling verticale
     *  pour les personnes suivies et les messages de la personne
     */
    private JScrollPane scroll, scrollAreaMe, scrollAreaOthers;

    /** Pour l'affichage des messages */
    private JTextArea areaMe, areaOthers;

    /** Pour pouvoir modifier la liste des utilisateurs */
    private DefaultListModel model;

    /** La barre Fichier etc. */
    private JMenuBar menuBar;

    /** Les différents menus (Fichier, Aide etc.) */
    private JMenu menuFichier;
    private JMenu menuAide;
    private JMenuItem menuAjoutSuivi;
    private JMenuItem menuDeconnexion;
    private JMenuItem menuQuitter;
    private JMenuItem menuAPropos;

    /** Menu pour chaque élément de la liste */
    private JPopupMenu menuList;
    private JMenuItem menuListItem;

    /** La Map des utilisateurs suivis, avec leur
     * numUtilisateur et leur pseudo
     */
    private Map<Integer, String> utilisateurSuivi;

    /** Mon numUtilisateur */
    private int myId;

    /** Champs des dates */
    private JFormattedTextField dateField1, dateField2;

    /** Précédent et suivant */
    private ImageIcon previous, next;

    /** Réseau RMI */
    private RequetesClient reqClient;

    /** Onglet */
    private JTabbedPane onglet;

    /** Messages de moi */
    List<Message> myMessages;

    /** Index du nombre de messages à afficher */
    int indexMessages = 0;

    /**
     * Constructeur par défaut
     */
    public JFClientConnecte(Utilisateur u) {
        onglet = new JTabbedPane();
        myMessages = new ArrayList<Message>();
        myId = u.getId();
        myPseudo = u.getPseudo();
        utilisateurSuivi = new HashMap<Integer, String>();
        model = new DefaultListModel();
        if (u.getUtilisateurSuivi().size() > 0) {
            Iterator<Integer> i = u.getUtilisateurSuivi().keySet().iterator();
            while (i.hasNext()) {
                Integer utilisateurNum = i.next();
                String pseudo = u.getUtilisateurSuivi().get(utilisateurNum);
                utilisateurSuivi.put(utilisateurNum, pseudo);
                // System.out.println(utilisateurNum + " " + pseudo);
            }
        }
        setProperties(u.getUtilisateurSuivi());
    }

    /**
     * Applique les propriétés pour la JFrame dont on hérite
     * @param utilisateurSuivi
     */
    public void setProperties(Map<Integer, String> utilisateurSuivi) {
        setTitle(TITRE + myPseudo);
        setBounds(ABSCISSE, ORDONNEE, LARGEUR, HAUTEUR);
        setResizable(false);
        getContentPane().setLayout(new BorderLayout());
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        fillJList(utilisateurSuivi);
        setComponents();
        setVisible(true);
    }

    /**
     * Ajoute le menu Fichier, Options, Aide...
     */
    private void addMenuBar() {
        menuBar = new JMenuBar();
        menuFichier = new JMenu(FICHIER);
        menuBar.add(menuFichier);

        menuAide = new JMenu(AIDE);
        menuBar.add(menuAide);

        setJMenuBar(menuBar);

        menuAjoutSuivi = new JMenuItem(AJOUT);
        menuFichier.add(menuAjoutSuivi);
        menuAjoutSuivi.addActionListener(this);

        menuDeconnexion = new JMenuItem(DCNX);
        menuFichier.add(menuDeconnexion);
        menuDeconnexion.addActionListener(this);

        menuQuitter = new JMenuItem(QUITTER);
        menuFichier.add(menuQuitter);
        menuQuitter.addActionListener(this);

        menuAPropos = new JMenuItem(APROPOS);
        menuAide.add(menuAPropos);
        menuAPropos.addActionListener(this);
    }

    /**
     * Place les composants dans la JFrame
     */
    @SuppressWarnings("serial")
    public void setComponents() {
        // On ajoute la barre de menus
        addMenuBar();

        // On créé et modifie le panel de gauche (utilisateurs)
        panelGauche = new JPanel(new FlowLayout());
        panelGauche.setBackground(BACKGROUND_COLOR);
        panelGauche.setLayout(new FlowLayout(FlowLayout.CENTER));

        panelGauche.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createTitledBorder(UTILISATEURS_SUIVIS),
                BorderFactory.createEmptyBorder(10, 10, 10, 10)));

        panelGauche.setPreferredSize(DIMENSION_PG);

        // On créé et modifie le panel de droite (messages)
        panelDroite = new JPanel(new FlowLayout());

        panelDroite.setLayout(new BoxLayout(panelDroite, BoxLayout.Y_AXIS));
        panelDroite.setBorder(BorderFactory.createCompoundBorder
                (BorderFactory.createTitledBorder
                        (MSG_ECRIT_PAR + myPseudo),
                        BorderFactory.createEmptyBorder(1, 1, 1, 1)));

        panelDroite.setBackground(BACKGROUND_COLOR);

        // Permet de ne pas pouvoir redimensionner les splitPane
        panelDroite.setMinimumSize(new Dimension(MIN_DIMENSION_PANEL));
        panelGauche.setMinimumSize(new Dimension(MIN_DIMENSION_PANEL));

        // Contiendra les messages
        areaMe = new JTextArea();

        // On ne peut pas modifier le texte dedans
        areaMe.setEditable(false);

        // Contiendra les messages
        areaOthers = new JTextArea();

        // On ne peut pas modifier le texte dedans
        areaOthers.setEditable(false);

        // On y ajoute la barre de scrolling
        scrollAreaMe = new JScrollPane(areaMe);
        scrollAreaMe.setPreferredSize(new Dimension(100, 350));
        scrollAreaMe.setVerticalScrollBarPolicy(
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

        scrollAreaOthers = new JScrollPane(areaOthers);
        scrollAreaOthers.setPreferredSize(new Dimension(100, 350));
        scrollAreaOthers.setVerticalScrollBarPolicy(
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

        onglet.addTab("Mes messages", null, scrollAreaMe, null);
        onglet.addTab("Autres utilisateurs", null, scrollAreaOthers, null);

        panelDroite.add(onglet);

        datePane = new JPanel(new FlowLayout());
        //datePane.setPreferredSize(new Dimension(10, 10));
        datePane.setBorder(BorderFactory.createEmptyBorder(10, 0, 10, 50));
        datePane.add(Box.createHorizontalGlue());
        datePane.add(Box.createRigidArea(new Dimension(10, 10)));

        datePane.add(debutDate);

        dateField1 = new JFormattedTextField(
                new SimpleDateFormat("dd/MM/yyyy")) {
            protected void processFocusEvent(FocusEvent event) {

                String date = dateField1.getText().trim();

                super.processFocusEvent(event);
                SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
                try {
                    // Si la Date n'est pas bonne, on rentre dans
                    // le bloc catch et on efface le JFormattedTextField
                    sdf.parse(date);
                } catch (ParseException ex) {
                    dateField1.setText("");
                }
            }  
        };
        dateField1.setPreferredSize(new Dimension(70, 23));
        dateField1.setEnabled(false);

        datePane.add(dateField1);

        datePane.add(finDate);

        dateField2 = new JFormattedTextField(
                new SimpleDateFormat("dd/MM/yyyy")) {
            protected void processFocusEvent(FocusEvent event) {

                String date = dateField2.getText().trim();

                super.processFocusEvent(event);
                SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
                try {
                    // Si la Date n'est pas bonne, on rentre dans
                    // le bloc catch et on efface le JFormattedTextField
                    sdf.parse(date);
                } catch (ParseException ex) {
                    dateField2.setText("");
                }
            }  
        };
        dateField2.setPreferredSize(new Dimension(70, 23));
        dateField2.setEnabled(false);

        datePane.add(dateField2);

        datePane.add(new JLabel(" "));

        boutonDate = new JButton(DATE);
        boutonDate.addActionListener(this);
        boutonDate.setEnabled(false);

        datePane.add(boutonDate);

        panelDroite.add(datePane);

        //Lay out the buttons from left to right.
        buttonPane = new JPanel(new FlowLayout());
        //buttonPane.setPreferredSize(new Dimension(10, 10));
        buttonPane.setBorder(BorderFactory.createEmptyBorder(10, 0, 10, 60));
        buttonPane.add(Box.createHorizontalGlue());
        buttonPane.add(Box.createRigidArea(new Dimension(10, 10)));

        BufferedImage myPicture;
        try {
            myPicture = ImageIO.read
                    (JFAuthentification.class.getResource
                            ("pictures/precedent.png"));
            previous = new ImageIcon(myPicture);

            myPicture = ImageIO.read
                    (JFAuthentification.class.getResource
                            ("pictures/suivant.png"));

            next = new ImageIcon(myPicture);
        } catch (IOException e) {
            System.err.println("Problème lors du chargement de l'image !");
        }

        boutonPrecedent = new JButton(previous);
        boutonPrecedent.setPreferredSize(new Dimension(30, 30));
        boutonPrecedent.addActionListener(this);

        boutonSuivant = new JButton(next);
        boutonSuivant.setPreferredSize(new Dimension(30, 30));
        boutonSuivant.addActionListener(this);

        buttonPane.add(boutonPrecedent);
        buttonPane.add(boutonSuivant);

        boutonSuivant.setEnabled(false);
        boutonPrecedent.setEnabled(false);

        panelDroite.add(buttonPane);

        // On initialise la JList avec la liste des utilisateurs
        list = new JList(model);

        // On ne peut sélectionner qu'un seul pseudo à la fois
        list.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
        list.setFixedCellHeight(27);
        DefaultListCellRenderer centerRenderer = new DefaultListCellRenderer();
        centerRenderer.setHorizontalAlignment(JLabel.CENTER);
        list.setCellRenderer(centerRenderer);
        list.addMouseListener(this);

        // On y ajoute aussi la barre de scrolling
        scroll = new JScrollPane(list);
        scroll.setPreferredSize(SCROLL_SIZE);
        scroll.setHorizontalScrollBarPolicy(
                ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);

        // On ajoute le scroll au panel gauche
        panelGauche.add(scroll);

        // Le splitPane avec une separation horizontale (barre à la verticale)
        splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, panelGauche,
                panelDroite);

        // Place la barre de séparation a 150 px
        splitPane.setDividerLocation(150);

        // On ajoute les différents boutons
        panelBouton = new JPanel(new BorderLayout());
        panelBouton.setLayout(null);
        panelBouton.setSize(LARGEUR_PAN_BOUTON, HAUTEUR_PAN_BOUTON);

        boutonEcrire = new JButton ("Ecrire");
        boutonEcrire.setBounds(390, 15, 90, 25);
        panelBouton.add(boutonEcrire);

        boutonAjouter = new JButton ("Ajouter");
        boutonAjouter.setBounds(485, 15, 90, 25);
        boutonAjouter.addActionListener(this);

        panelBouton.add(boutonAjouter);
        boutonEcrire.addActionListener(this);

        // Utilisation d'une balise html car texte trop long dans
        // le JButton
        boutonSupprimer = new JButton ("<html>Supprimer</html>");
        boutonSupprimer.setBounds(580, 15, 90, 25);
        boutonSupprimer.setEnabled(false);
        boutonSupprimer.addActionListener(this);
        panelBouton.add(boutonSupprimer);

        // Ajout du popupMenu à chaque élément de la Jlist
        // pour pouvoir supprimer l'utilisateur sélectionné
        menuList = new JPopupMenu();
        menuListItem = new JMenuItem("Supprimer");
        menuListItem.addActionListener(this);
        menuList.add(menuListItem);
        scroll.setComponentPopupMenu(menuList);

        // On ajoute le panneau final qui contient tous les autres
        splitPane2 = new JSplitPane(JSplitPane.VERTICAL_SPLIT, splitPane,
                panelBouton);
        splitPane2.setDividerLocation(490);

        add(splitPane2);

        // Affiche les 5 premiers messages me correspondant à partir du
        // 1er message
        afficheAndFillMessages(5, myId, areaMe);
    }

    /**
     * Initialise la JList
     * @param utilisateurSuivi, les utilisateurs déjà suivis
     */
    public void fillJList(Map<Integer, String> utilisateurSuivi) {
        if (utilisateurSuivi.size() > 0) {
            for (String pseudo : utilisateurSuivi.values()) {
                model.addElement(pseudo);
            }
        }
    }

    /**
     * Permet d'afficher les messages de l'utilisateur
     * TODO : Ecrire en allant chercher les messages
     *        dans la base de données
     */
    public void afficheAndFillMessages
    (int nbMessages, int id, JTextArea textArea) {
        try {
            RequetesClient rClient = new RequetesClient();
            myMessages = rClient.recupererMessages(
                    indexMessages, nbMessages, id);
            String text = "";
            for (Message m : myMessages) {
                text += "Ecrit le " + m.getDateCreation()
                        + "\n\n" + m.getMessage()
                        + "\n             ===================================="
                        + "\n";
            }
            myMessages.clear();
            textArea.setText(text);
        } catch (NotBoundException ex) {
            // TODO Auto-generated catch block
            ex.printStackTrace();
        }
        /*
        String t = "";
        String pseudo = list.getSelectedValue().toString();

        for (int i = 100; i > 0; i--) {
            t += pseudo + " : Message " + i + "\n";

            for (int j = 0; j < 25; j++) {
                t += "=";
            }

            t += i == 1 ? "" : "\n";
        }
        areaMe.setText(t);

        areaMe.setCaretPosition(0);

        t = "";

        for (int i = 100; i > 0; i--) {
            t += pseudo + " others" + " : Message " + i + "\n";

            for (int j = 0; j < 25; j++) {
                t += "=";
            }

            t += i == 1 ? "" : "\n";
        }
        areaOthers.setText(t);

        areaOthers.setCaretPosition(0);*/
    }

    /**
     * Permet de savoir si l'id entré est correct
     * @param id, l'id entré
     */
    private static void checkIdEntered(int id) {
        // Ajout de l'utilisateur, si déjà suivi ou
        // n'existe pas, afficher une JDialog d'erreur
        if (id == -1) {
            // Erreur
            new JDError("Utilisateur déjà suivi !");
        } else if (id == -2) {
            new JDError("Vous ne pouvez pas vous suivre !");
        } else if (id == -3) {
            // N'existe pas dans la base de données
            new JDError("Cet utilisateur n'existe pas !");
        }
    }

    /**
     * Permet d'ajouter une personne à suivre
     */
    private void ajoutIdASuivre() {

        List<Integer> listNumutilisateurSuivi = new ArrayList<Integer>();

        // On ajoute les numUtilisateur suivis
        for (int numUtilisateur : utilisateurSuivi.keySet()) {
            listNumutilisateurSuivi.add(numUtilisateur);
        }

        JDAjoutSuivi JDAjout = new JDAjoutSuivi(myId, listNumutilisateurSuivi);

        // On a annulé dans JDAjoutSuivi
        if (JDAjout.getIdAndPseudo().size() != 0) {

            Map<Integer, String> idAndPseudo =
                    JDAjout.getIdAndPseudo();

            int numUtilisateurSuivi = idAndPseudo.keySet().iterator().next();

            // on regarde la valeur retounée
            checkIdEntered(numUtilisateurSuivi);

            String pseudoSuivi = idAndPseudo.values().iterator().next();

            if (pseudoSuivi != null) {
                // On l'ajoute à la liste des utilisateurs suivis
                // et à la JList
                utilisateurSuivi.put(numUtilisateurSuivi, pseudoSuivi);
                model.addElement(pseudoSuivi);
            }
        }
    }

    /**
     * Permet de supprimer l'utilisateur sélectionné
     * dans la JList ainsi que dans la base de données
     * @param numUserToDelete, le numéro de l'utilisateur
     *        à supprimer
     */
    private void removeUser(int numUserToDelete) {
        try {
            RequetesClient rClient = new RequetesClient();

            rClient.removeNumUtilisateur(myId, numUserToDelete);
            model.remove(model.indexOf(list.getSelectedValue()));

            // On l'enlève de la HashMap
            utilisateurSuivi.remove(numUserToDelete);

            // On reset l'affiche des messages
            areaMe.setText("");

            // Aucun élément de la JList n'est sélectionné
            boutonSuivant.setEnabled(false);
            boutonPrecedent.setEnabled(false);
            boutonDate.setEnabled(false);
            dateField1.setEnabled(false);
            dateField2.setEnabled(false);

        } catch (NotBoundException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Lorsqu'un évènement est déclenché
     * @param ev, l'évènement
     */
    public void actionPerformed(ActionEvent ev) {
        // Appui sur déconnexion
        if (ev.getSource() == menuDeconnexion) {
            // Enlever l'utilisateur connecté grâce au booléen,
            // etc (passer le user à null ?)
            new JFAuthentification();
            dispose();
        } else if (ev.getSource() == menuAjoutSuivi) {
            ajoutIdASuivre();
        } else if (ev.getSource() == menuQuitter) {
            // Enlever l'utilisateur connecté grâce au booléen, etc
            dispose();
        } else if (ev.getSource() == menuAPropos) {
            new JDAPropos("Loïc Martinez");
        } else if (ev.getSource() == boutonAjouter) {
            ajoutIdASuivre();
        } else if (ev.getSource() == boutonEcrire) {
            // On récupère le texte écrit
            String texte;
            JDEcrireMessage jdMess = new JDEcrireMessage();
            if (jdMess.isEnvoye()) {
                texte = jdMess.getText();
                // Si le texte est non-vide, on fait le INSERT INTO dans la
                // base de données
                if (! texte.equals("")) {
                    // Et on réactualise la liste des messages de l'utilisateur
                    // dans l'interface graphique
                    try {
                        reqClient = new RequetesClient();

                        try {
                            reqClient.envoyerMessage(myId, texte);
                            Calendar now = Calendar.getInstance();

                            // On affiche le message sur la console 
                            String dateNow = now.get(Calendar.DAY_OF_MONTH)
                                    + "/" + now.get(Calendar.MONTH) + "/"
                                    + now.get(Calendar.YEAR)
                                    + " " + now.get(Calendar.HOUR_OF_DAY) + ":"
                                    + now.get(Calendar.MINUTE)
                                    + ":" + now.get(Calendar.SECOND);
                            Time tm = new Time(now.get(Calendar.DAY_OF_MONTH),
                                    now.get(Calendar.MONTH),
                                    now.get(Calendar.YEAR));
                            Message m = new Message(texte, tm);
                            String t = "Ecrit le " + m.getDateCreation()
                            + "\n\n" + m.getMessage()
                            + "\n "
                            + "            ===================================="
                            + "\n";
                            
                            String texteAvant = t + areaMe.getText();
                            areaMe.setText(texteAvant);
                            areaMe.setCaretPosition(0);
                            
                        } catch (java.lang.NullPointerException ex) {
                            new JDError("Connexion au serveur"
                                    + " impossible !");
                        }

                    } catch (java.rmi.NotBoundException ex) {
                        new JDError("Connexion au serveur impossible !");
                    }
                }
            }
        } else if (ev.getSource() == boutonSupprimer) {
            int numUtilisateurASupprimer = -1;

            // On récupère le numUtilisateur associé au pseudo
            for (Entry<Integer, String> entry : utilisateurSuivi.entrySet()) {
                if (entry.getValue().equals(
                        list.getSelectedValue().toString())) {
                    numUtilisateurASupprimer = entry.getKey();
                }
            }

            removeUser(numUtilisateurASupprimer);
        } else if (ev.getSource() == menuListItem) { // Supprimer

            int numUtilisateurASupprimer = -1;

            // On récupère le numUtilisateur associé au pseudo
            for (Entry<Integer, String> entry : utilisateurSuivi.entrySet()) {
                if (entry.getValue().equals(
                        list.getSelectedValue().toString())) {
                    numUtilisateurASupprimer = entry.getKey();
                }
            }

            removeUser(numUtilisateurASupprimer);
        } else if (ev.getSource() == boutonPrecedent) {
            // Appui sur pécédent est l'index des messages est
            // déjà à 0, ne rien faire    
            if (indexMessages > 0) {
                // Charger les messages suivants
                // Sauf si ce sont les derniers messages
                // A faire en mettant les méthodes client serveur
                // pour récupérer ceux-ci en boolean
                try {
                    RequetesClient rc = new RequetesClient();
                    // On regarde si c'est mes messages qu'il faut regarder
                    // ou ceux de quelqu'un de sélectionné
                    // 0 -> Mes messages
                    // 1 -> Autres utilisateurs
                    if (onglet.getSelectedIndex() == 0) {
                        myMessages = rc.recupererMessages(
                                indexMessages * NB_DISPLAY_MESSAGES,
                                5, myId);
                    } else if (onglet.getSelectedIndex() == 1) {
                     // On récupère le numUtilisateur associé au pseudo
                        int numUser = 0;
                        for (Entry<Integer, String> entry : 
                            utilisateurSuivi.entrySet()) {
                            if (entry.getValue().equals(
                                    list.getSelectedValue().toString())) {
                                numUser = entry.getKey();
                            }
                        }
                        
                        myMessages = rc.recupererMessages(
                                indexMessages * NB_DISPLAY_MESSAGES,
                                5, numUser);
                    }
                } catch (NotBoundException ex) {
                    // TODO Auto-generated catch block
                    ex.printStackTrace();
                }
            }
        }
    }

    /**
     * Quand on clique sur un utilisateur
     */
    @Override
    public void mouseClicked(MouseEvent ev) {

        // Si sélection d'un élément de la JList
        // avec un clic droit
        // TODO-FIX : Le JPopupMenu ne suit pas le scroll !!
        if (ev.getButton() == 3) {
            int index = list.locationToIndex(ev.getPoint());
            list.setSelectedIndex(index);
            menuList.show(scroll, ev.getX(), ev.getY());
        }

        // Appui sur un pseudo, aller chercher tous les messages
        // qui ont été écrits
        //afficheMessages();

        boutonSuivant.setEnabled(true);
        boutonPrecedent.setEnabled(true);
        boutonDate.setEnabled(true);
        dateField1.setEnabled(true);
        dateField2.setEnabled(true);
    }

    @Override
    public void mouseEntered(MouseEvent arg0) {

    }

    @Override
    public void mouseExited(MouseEvent arg0) {

    }

    @Override
    public void mousePressed(MouseEvent arg0) {

    }

    @Override
    public void mouseReleased(MouseEvent arg0) {

    }
}